home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / pluginy Firefox / 6984 / 6984.xpi / chrome / lazarus.jar / content / common.js < prev    next >
Text File  |  2009-11-24  |  15KB  |  499 lines
  1.  
  2. /**
  3. * common functions used by our code
  4. */
  5.  
  6. //declare namespace
  7. this.Lazarus = this.Lazarus || {};
  8.  
  9. Lazarus.$ = function(id, doc){
  10.     doc = doc || document;
  11.     return doc.getElementById(id);
  12. }
  13.  
  14. Lazarus.build = 473;
  15.  
  16. //some form types used in the database.
  17. Lazarus.FORM_TYPE_NORMAL = 0;
  18. Lazarus.FORM_TYPE_AUTOSAVE = 1;
  19. Lazarus.FORM_TYPE_STALE_AUTOSAVE = 2;
  20. Lazarus.FORM_TYPE_TEMPLATE = 3;
  21.  
  22. //version number for saved forms
  23. //increment this when making major changes to the way form info is saved/restored
  24. //and you want to allow for legacy code. 
  25. Lazarus.FORM_INFO_VERSION = 1;
  26.  
  27. /**
  28. * return a browser window
  29. */
  30. Lazarus.getBrowser = function(){
  31.     var wm = Components.classes["@mozilla.org/appshell/window-mediator;1"].getService(Components.interfaces.nsIWindowMediator);
  32.     return wm.getMostRecentWindow("navigator:browser");
  33. }
  34.  
  35. /**
  36. * return an installed extension
  37. */
  38. Lazarus.getExtension = function(extId){
  39.     var em = Components.classes["@mozilla.org/extensions/manager;1"].getService(Components.interfaces.nsIExtensionManager);
  40.     // Change extension-guid@example.org to the GUID of the extension whose version
  41.     // you want to retrieve, e.g. foxyproxy@eric.h.jung for FoxyProxy
  42.     return em.getItemForID(extId);
  43. }
  44.  
  45. /**
  46. * return a human readable version string for lazarus
  47. */
  48. Lazarus.getVersionStr = function(){
  49.     var addon = Lazarus.getExtension(Lazarus.guid);
  50.     return addon.version;
  51. }
  52.  
  53. /**
  54. * trims leading and trailing whitespace from a string
  55. */
  56. Lazarus.trim = function(str){
  57.     return str.replace(/^\s+/, '').replace(/\s+$/, '');
  58. }
  59.  
  60. /**
  61. * return true if value is in an array 
  62. * strings do a case insensitive search 
  63. */
  64. Lazarus.inArray = function(val, arr){
  65.     if (typeof val == "string"){
  66.         val = val.toLowerCase();
  67.     }
  68.     for (var i=0; i<arr.length; i++){
  69.         var arrVal = (typeof arr[i] == "string") ? arr[i].toLowerCase() : arr[i];
  70.         if (val == arrVal){
  71.             return true;
  72.         }
  73.     }
  74.     return false;
  75. }
  76.  
  77.  
  78. /**
  79. * convert a (one dimentional) array of values onto a hash table 
  80. */
  81. Lazarus.arrayToHashTable = function(arr){
  82.     var table = {};
  83.     for (var i=0; i<arr.length; i++){
  84.         table[arr[i]] = true;
  85.     }
  86.     return table;
  87. }
  88.  
  89. /**
  90. * return TRUE if object is an array
  91. */
  92. Lazarus.isArray = function(obj){
  93.     return (typeof obj == "object" && typeof obj.length === 'number' && !obj.propertyIsEnumerable('length'));
  94. }
  95.  
  96. /**
  97. * return a nicely formatted date-time 
  98. * default format is "YYYY-MM-DD HH:MM:SS"
  99. */
  100. Lazarus.formatDate = function(date, justDate){
  101.     var y = Lazarus.pad(date.getFullYear(), 4);
  102.     var m = Lazarus.pad(date.getMonth()+1, 2);
  103.     var d = Lazarus.pad(date.getDate(), 2);
  104.     var h = Lazarus.pad(date.getHours(), 2);
  105.     var n = Lazarus.pad(date.getMinutes(), 2);
  106.     var s = Lazarus.pad(date.getSeconds(), 2);
  107.     
  108.     return (justDate) ? (y +"-"+ m +"-"+ d) : (y +"-"+ m +"-"+ d +" "+ h +":"+ n +":"+ s);
  109. }
  110.  
  111.  
  112. /**
  113. * return a string form at of the number with commas
  114. */
  115. Lazarus.formatNumber = function(num){
  116.     var str = num.toString();
  117.     
  118.     //split into integer and decimal places
  119.     var s = str.split(".");
  120.     var sInt = s[0];
  121.     var sDec = s[1] ? ("."+ s[1]) : '';
  122.     var m;
  123.     //add a comma between every 3 digits 
  124.     while(m = sInt.match(/(\d+)(\d{3})/)){
  125.         sInt = m[1] +","+ m[2]; 
  126.     }
  127.     //and re-attach any decimals
  128.     return sInt + sDec;
  129. }
  130.  
  131. /**
  132. * pad a number to the appropriate length
  133. */
  134. Lazarus.pad = function(num, minLen, padChar){
  135.     padChar = padChar || "0"
  136.     var s = num.toString();
  137.     while (s.length < minLen){
  138.         s = "0"+ s;
  139.     }
  140.     return s;
  141. }
  142.  
  143.  
  144. /**
  145. * converts a URL string to a URI that is used in many firefox functions
  146. */
  147. Lazarus.urlToURI = function(url){
  148.     try {
  149.         var uri = Components.classes["@mozilla.org/network/io-service;1"].getService(Components.interfaces.nsIIOService).newURI(url, null, null);
  150.         //how screwed is this? if I try to access uri.host and the url doesn't have one (eg aim:bob) then an error is thrown!
  151.         var safeURI = {}
  152.         for(var key in uri){
  153.             safeURI[key] = '';
  154.             try {
  155.                 safeURI[key] = uri[key];
  156.             }catch(e){}
  157.         }
  158.         return safeURI;
  159.     }catch(e){
  160.         return null;
  161.     }
  162. }
  163.  
  164.  
  165.  
  166. /**
  167. * helper when calculating window size
  168. */
  169. Lazarus.showWindowSizeHelper = function(){
  170.     if (Lazarus.getBrowser().Lazarus.getExtPref("debugMode") >= 4){
  171.         window.addEventListener("resize", function(){
  172.             document.origTitle = document.origTitle || document.title;
  173.             document.title = document.origTitle +": "+ window.outerWidth +" x "+ window.outerHeight;
  174.         }, false);
  175.     }
  176. }
  177.  
  178. /**
  179. * logging levels 
  180. */
  181. Lazarus.DEBUG_TYPE_NONE = 0;
  182. Lazarus.DEBUG_TYPE_ERROR = 1;
  183. Lazarus.DEBUG_TYPE_WARNING = 2;
  184. Lazarus.DEBUG_TYPE_MESSAGE = 3;
  185.  
  186. /**
  187. * return TRUE if obj is an error
  188. */
  189. Lazarus.isError = function(obj){
  190.     //doesn't always work
  191.     //return (obj instanceof Error);
  192.     return (obj && obj.stack && obj.message);
  193. }
  194.  
  195. /**
  196. * logs a message to the error console
  197. */
  198. Lazarus.logErrorMessage = function(args, type){
  199.     
  200.     var msg = "Lazarus: ";
  201.     
  202.     if (Lazarus.isError(args[0])){
  203.         msg += args[0].message +"\n";
  204.         for (var i=1; i<args.length; i++){
  205.             msg += args[i] +"\n";
  206.         }
  207.     }
  208.     else {
  209.        for (var i=0; i<args.length; i++){
  210.             msg += args[i] +"\n";
  211.         }
  212.     }    
  213.     
  214.     var consoleService = Components.classes["@mozilla.org/consoleservice;1"].getService(Components.interfaces.nsIConsoleService);
  215.     if (type == Lazarus.DEBUG_TYPE_MESSAGE){
  216.         consoleService.logStringMessage(msg);
  217.     }
  218.     else {
  219.         var scriptError = Components.classes["@mozilla.org/scripterror;1"].createInstance(Components.interfaces.nsIScriptError);
  220.         var flag = (type == Lazarus.DEBUG_TYPE_WARNING) ? scriptError.warningFlag : scriptError.errorFlag;
  221.         if (Lazarus.isError(args[0])){
  222.             scriptError.init(msg, args[0].fileName, null, args[0].lineNumber, null, flag, "component javascript");
  223.         }
  224.         else {
  225.             scriptError.init(msg, null, null, null, null, flag, "component javascript");
  226.         }
  227.         consoleService.logMessage(scriptError);   
  228.     }
  229. }
  230.         
  231.         
  232. /**
  233. * log an error to the error console
  234. * err can be an Error object or a string
  235. */
  236. Lazarus.error = function(){
  237.     if (Lazarus.getPref("extensions.lazarus.debugMode") >= Lazarus.DEBUG_TYPE_ERROR){
  238.         Lazarus.logErrorMessage(arguments, Lazarus.DEBUG_TYPE_ERROR);
  239.     }
  240. }
  241.  
  242. /**
  243. * logs a warning message to the error console
  244. */
  245. Lazarus.warning = function(){
  246.     if (Lazarus.getPref("extensions.lazarus.debugMode") >= Lazarus.DEBUG_TYPE_WARNING){
  247.         Lazarus.logErrorMessage(arguments, Lazarus.DEBUG_TYPE_WARNING);
  248.     }
  249. }
  250.  
  251. /**
  252. * logs a message to the error console
  253. */
  254. Lazarus.debug = function(){
  255.     if (Lazarus.getPref("extensions.lazarus.debugMode") >= Lazarus.DEBUG_TYPE_MESSAGE){
  256.         Lazarus.logErrorMessage(arguments, Lazarus.DEBUG_TYPE_MESSAGE);
  257.     }
  258. }
  259.  
  260. /**
  261. * dump an object and all it's properties to the error console
  262. */
  263. Lazarus.dump = function(obj){
  264.     var msg = ''
  265.     for(var prop in obj){
  266.         msg += prop +"=";
  267.         try {
  268.             msg += obj[prop]
  269.         }catch(e){
  270.             msg += "?"
  271.         }
  272.         msg += "["+ typeof(obj[prop]) +"]\n";
  273.     }
  274.     Lazarus.debug(msg);
  275. }
  276.  
  277. /**
  278. * preference code (logging requires prefs)
  279. */
  280. Lazarus.Pref = Lazarus.Pref || {};
  281.  
  282. /**
  283. * "listens" for changes to the given preference and fires the given function when the preference changes
  284. * ref: http://developer.mozilla.org/en/docs/Code_snippets:Preferences#Using_preference_observers
  285. */
  286. Lazarus.Pref.addObserver = function(prefId, func){
  287.  
  288.     //split the prefId into branch and leaf
  289.     var pos = prefId.lastIndexOf(".");
  290.     if (pos == -1){
  291.         throw Error("Pref.addObserver() prefId must contain a '.' ["+ prefId +"]");
  292.     }
  293.     
  294.     var leaf = prefId.substr(pos);
  295.     var branch = prefId.substr(0, pos);
  296.  
  297.     var observer = {
  298.       register: function(){
  299.         var prefService = Components.classes["@mozilla.org/preferences-service;1"].getService(Components.interfaces.nsIPrefService);
  300.         this._branch = prefService.getBranch(branch);
  301.         this._branch.QueryInterface(Components.interfaces.nsIPrefBranch2);
  302.         this._branch.addObserver("", this, false);
  303.       },
  304.  
  305.       unregister: function(){
  306.         if (!this._branch) return;
  307.         this._branch.removeObserver("", this);
  308.       },
  309.  
  310.       observe: function(aSubject, aTopic, aData){
  311.         if(aTopic != "nsPref:changed") return;
  312.         
  313.         //TODO: add "getPref" and pass new preference to function?
  314.         if (aData == leaf){
  315.             func();
  316.         }
  317.       }
  318.     }
  319.     observer.register();
  320.         window.addEventListener("unload", function(){
  321.             observer.unregister();
  322.         }, false);
  323.         
  324.     return observer;
  325. }
  326.  
  327. /**
  328. * forces Firefox to save the prefs file
  329. */
  330. Lazarus.Pref.savePrefFile = function(key, val){
  331.     var prefService = Components.classes["@mozilla.org/preferences-service;1"].getService(Components.interfaces.nsIPrefService);
  332.     prefService.savePrefFile(null);
  333. }
  334.  
  335.  
  336. /**
  337. * return a preference
  338. */
  339. Lazarus.getPref = function(name, defaultVal){
  340.     
  341.     try {
  342.         var branch = Components.classes["@mozilla.org/preferences-service;1"].getService(Components.interfaces.nsIPrefBranch);
  343.         switch (branch.getPrefType(name)){
  344.             case 32 : //string
  345.                 return  branch.getCharPref(name);
  346.             case 64 : //int
  347.                 return branch.getIntPref(name);
  348.             case 128: //bool
  349.                 return branch.getBoolPref(name);
  350.             default:                        
  351.         }
  352.     }
  353.     catch(e){}
  354.     
  355.     if (typeof(defaultVal) !== "undefined"){
  356.         return defaultVal;
  357.     }
  358.     else {
  359.         throw Error("Lazarus: Unsupported preference datatype ["+ name +","+ branch.getPrefType(name) +"]");
  360.     }
  361. }
  362.  
  363. /**
  364. * set a preference
  365. */
  366. Lazarus.setPref = function(name, val){
  367.  
  368.     var branch = Components.classes["@mozilla.org/preferences-service;1"].getService(Components.interfaces.nsIPrefBranch);
  369.     
  370.     switch (typeof(val)){
  371.         case "boolean":
  372.             branch.setBoolPref(name, val);
  373.             return true;
  374.             
  375.         case "string":
  376.             branch.setCharPref(name, val);
  377.             return true;
  378.         
  379.         case "number":
  380.             branch.setIntPref(name, val);
  381.             return true;
  382.         
  383.         default:
  384.             throw Error("Unable to save pref of type "+ typeof(val));
  385.     }
  386. }
  387.  
  388. //increase a preference value by inc (default 1) 
  389. //return the new value
  390. Lazarus.incPref = function(name, inc){
  391.     var newVal = Lazarus.getPref(name, 0) + (inc || 1);
  392.     Lazarus.setPref(name, newVal);
  393.     return newVal;
  394. }
  395.  
  396.  
  397. /**
  398. * delete a pref branch
  399. */
  400. Lazarus.killPref = function(name){
  401.     var branch = Components.classes["@mozilla.org/preferences-service;1"].getService(Components.interfaces.nsIPrefBranch);
  402.     branch.deleteBranch(name);
  403. }
  404.  
  405. /**
  406. * returns a preference from the "extensions.lazarus" branch
  407. */
  408. Lazarus.getExtPref = function(key, defaultVal){
  409.     return Lazarus.getPref("extensions.lazarus."+ key, defaultVal);
  410. }
  411.  
  412. /**
  413. * sets a preference in the "extensions.lazarus" branch
  414. */
  415. Lazarus.setExtPref = function(key, val){
  416.     return Lazarus.setPref("extensions.lazarus."+ key, val);
  417. }
  418.  
  419. /**
  420. * return the current documents URL
  421. */
  422. Lazarus.currentURL = function(){
  423.     try {
  424.         return content.document.URL;
  425.     }catch(e){
  426.         return '';
  427.     }
  428. }
  429.  
  430.  
  431.  
  432. /**
  433. * resize a preference window to fit the content of it's largest pane
  434. */
  435. Lazarus.sizePrefWindowToContent = function(){
  436.     // Localize strings aren't used when the initial height is used to calculate the size of the context-box
  437.     // and preference window.  The height is calculated correctly once the window is drawn, but the context-box
  438.     // and preference window heights are never updated.
  439.     var panes = document.getElementsByTagName('prefpane');
  440.     var diffX = 0;
  441.     var diffY = 0;
  442.     
  443.     for (var i=0; i<panes.length; i++){
  444.         var pane = panes[i];
  445.         //we need to grab the boxObject of the container (XUL:vbox .content-box), not the pane itself (pane has padding which makes life difficult)
  446.         var contentBox = pane.boxObject.firstChild.boxObject;
  447.         
  448.         //check to see if there are elements within the box that go beyond the boxes borders
  449.         for (var j=0; j<pane.childNodes.length; j++){
  450.             var child = pane.childNodes[j];
  451.             if (child.boxObject){
  452.                 if ((child.boxObject.screenX + child.boxObject.width) > (contentBox.screenX + contentBox.width + diffX)){
  453.                     diffX = (child.boxObject.screenX + child.boxObject.width) - (contentBox.screenX + contentBox.width)
  454.                 }
  455.                 if ((child.boxObject.screenY + child.boxObject.height) > (contentBox.screenY + contentBox.height + diffY)){
  456.                     diffY = (child.boxObject.screenY + child.boxObject.height) - (contentBox.screenY + contentBox.height)
  457.                 }
  458.             }
  459.         }
  460.     }
  461.     
  462.     if (diffX > 0 || diffY > 0){
  463.         window.resizeTo(window.outerWidth + diffX, window.outerHeight + diffY);
  464.     }
  465. }
  466.  
  467. /**
  468. * extract the key/value pairs from the query string of a url
  469. */
  470. Lazarus.getUrlQuery = function(url){
  471.     var uri = Lazarus.urlToURI(url);
  472.     
  473.     var query = uri.path.replace(/^[^\?]*\?/, '').replace(/#.*$/, '');
  474.     
  475.     //split the query string into key/value pairs
  476.     var pairs = (query.indexOf("&") > -1) ? query.split(/&/g) : query.split(/&/g);
  477.     
  478.     //and then split each pair into its separate key/value
  479.     var values = {};
  480.     for(var i=0; i<pairs.length; i++){
  481.       var bits = pairs[i].split(/=/);
  482.         var key = decodeURIComponent(bits[0]);
  483.         var value = bits[1] ? decodeURIComponent(bits[1]) : '';
  484.         if (typeof values[key] === "undefined"){
  485.             values[key] = value;
  486.         }
  487.         else if (Lazarus.isArray(values[key])){
  488.             values[key].push(value);
  489.         }
  490.         else {
  491.             //need to turn the previous value into an array of values
  492.             values[key] = new Array(values[key]);
  493.             values[key].push(value);
  494.         }
  495.     }
  496.  
  497.     //return the key requested, or all keys
  498.     return (arguments.length == 2) ? values[arguments[1]] : values;
  499. }